import momentMini from 'moment-mini'

export const getUrlQuery = (url) => {
  if (url && url.indexOf('?') !== -1) {
    const args = new Object() // 声明一个空对象

    // 获取URL中全部参数列表数据，第一个？号后面的都是query
    // 修复url上有多个？而被分割多段
    let query = '&' + url.replace(/[^?]*\?/, '')
    if (query.indexOf('#') !== -1) {
      query = query.split('#')[0]
    }
    const pairs = query.split('&') // 以 & 符分开成数组
    for (let i = 0; i < pairs.length; i++) {
      const pos = pairs[i].indexOf('=') // 查找 "key=value" 对
      if (pos === -1) continue // 若不成对，则跳出循环继续下一对
      const argName = pairs[i].substring(0, pos) // 取参数名
      let value = pairs[i].substring(pos + 1) // 取参数值
      value = decodeURIComponent(value) // 若需要，则解码
      args[argName] = value // 存成对象的一个属性
    }
    return args
  } else {
    return {}
  }
}

export const getUrlParams = (params) => {
  let paramStr = ''
  Object.keys(params)
    .forEach((item) => {
      if (paramStr === '') {
        paramStr = `${item}=${params[item]}`
      } else {
        paramStr = `${paramStr}&${item}=${params[item]}`
      }
    })
  return paramStr
}

export const getPageUrl = (openPath, params) => {
  console.log('源数据路径', openPath)
  let originPath = openPath
  const pathIndex = originPath.indexOf('?')
  if (pathIndex > -1) {
    originPath = originPath.slice(0, pathIndex)
  }
  let urlQuery = getUrlQuery(openPath) // 解析参数
  urlQuery = {
    ...urlQuery,
    ...params
  }
  const urlParams = getUrlParams(urlQuery) // 拼接参数
  const pagePath = `${originPath}?${urlParams}`
  return pagePath
}

// 获取数组连续的值 返回二维数组
export function seriesIntArray(arr) {
  const newArr = []; let i = 0
  newArr[i] = [arr[0]]
  arr.reduce(function(prev, cur) {
    cur - prev === 1 ? newArr[i].push(cur) : newArr[++i] = [cur]
    return cur
  })
  return newArr
}

// 分转小时分  mm  to HH:mm
export function changeMinToHourMin(str) {
  if (str !== 0 && str !== '' && str != null) {
    return ((Math.floor(str / 60)).toString().length < 2 ? '0' + (Math.floor(str / 60)).toString()
      : (Math.floor(str / 60)).toString()) + ':' + ((str % 60).toString().length < 2 ? '0' + (str % 60).toString() : (str % 60).toString())
  } else {
    return '00:00'
  }
}

// 小时分转分 HH:mm to mm
export function changeHourMinToMin(str) {
  if (str && str.split(':').length === 2) {
    return str.split(':')[0] * 60 + +str.split(':')[1]
  } else {
    return 0
  }
}

// 报表时间
export function getFilterFormPastTime(days) {
  return new Promise((resolve, reject) => {
    const dateArr = []
    switch (days) {
      case 'yesterday':
        dateArr[0] = momentMini().subtract(1, 'days').format('YYYY-MM-DD') + ' 00:00:00'
        dateArr[1] = momentMini().subtract(1, 'days').format('YYYY-MM-DD') + ' 23:59:59'
        break
      case 'nowMonth':
        dateArr[0] = momentMini().startOf('month').format('YYYY-MM-DD') + ' 00:00:00'
        dateArr[1] = momentMini().format('YYYY-MM-DD HH:mm:ss')
        break
      default:
        dateArr[0] = momentMini().subtract(days - 1, 'days').format('YYYY-MM-DD') + ' 00:00:00'
        // dateArr[1] = momentMini().format('YYYY-MM-DD HH:mm:ss');
        dateArr[1] = momentMini().format('YYYY-MM-DD') + ' 23:59:59'
        break
    }
    resolve(dateArr)
  })
}

// 获取会员卡使用说明说明  特权说明
export function formatCardExplain(data, enableConsumeBonus = false) {
  const params = {}
  // 拼接使用说明instructionsObj
  const instructionsArray = []
  //  1.开卡门槛payType
  switch (data.category.payType) {
    case 1:
      instructionsArray.push(
        '无开卡门槛。'
      )
      break
    case 2:
      instructionsArray.push(
        `付费${data.category.payCost / 100}元开卡。`
      )
      if (data.category.enablePayDifference) {
        instructionsArray.push(
          '升级到该卡时支持差额升级，需支付原会员卡与当前会员卡的开卡费的差额升级。'
        )
      }

      break
    case 3:
      if (data.category.validPeriod !== 0 && data.category.annualFee !== 0) {
        instructionsArray.push(
          `充值${data.category.rechargeCost / 100}元开卡${data.category.firstYearFree ? '' : `，充值金额包含了${data.category.annualFee / 100}元年费，在开通成功后从余额扣除`}。`
        )
      } else {
        instructionsArray.push(
          `充值${data.category.rechargeCost / 100}元开卡。`
        )
      }
      break
    case 4:
      instructionsArray.push(
        '仅人工开卡。'
      )
      break
  }
  // 2.有效期validPeriod 3.年费annualFee
  if (data.category.validPeriod === 0) {
    instructionsArray.push('会员卡永久有效。')
  } else {
    instructionsArray.push(
      `会员卡自领取日起${data.category.validPeriod}年有效。`
    )
    if (data.category.annualFee !== 0) {
      if (data.category.firstYearFree) {
        instructionsArray.push(
          `会员卡需要每年缴纳${data.category.annualFee / 100}元年费，开卡免首年年费。`
        )
      } else {
        instructionsArray.push(
          `会员卡需要每年缴纳${data.category.annualFee / 100}元年费。`
        )
      }

      if (data.category.enableAnnualfeeDifference) {
        instructionsArray.push(
          '升级卡时支持差额升级，需支付原会员卡与当前会员卡的年费的差额升级。'
        )
      }

      if (data.category.autoRenew) {
        instructionsArray.push(
          '会员卡到期当天如果会员余额充足，则直接从余额自动扣除年费。'
        )
      }
      instructionsArray.push(
        '年费自动扣除或者缴纳成功后，会员卡有效期自动延长一年。'
      )
    }
  }
  // 使用限制说明
  if (data.category.payType === 4 && data.category.hasUseLimit && data.category.useLimitRule) {
    if (!data.useLimitRule.allowRecharge) {
      instructionsArray.push(
        '此卡不允许顾客线上充值或者POS机等线下充值 ( 注意: 不影响商户后台修改会员卡余额 )。'
      )
    }
    if (data.useLimitRule.allowChangeCategory) {
      instructionsArray.push(
        '此卡顾客可以自助在小程序升级/降级到其他会员卡( 注意: 顾客升级到其他会员卡后此卡的过期规则将永久不会生效 )。'
      )
    }
    if (data.useLimitRule.balanceClearChange) {
      instructionsArray.push(
        '此卡顾客升级/降级到其他会员卡会自动清零现有实充账户的余额。'
      )
    }
    if (data.useLimitRule.giftClearChange) {
      instructionsArray.push(
        '此卡顾客升级/降级到其他会员卡会自动清零现有赠送账户的余额。'
      )
    }
    if (!data.useLimitRule.allowRenewCard) {
      instructionsArray.push(
        '此卡过期后该卡会员不可续费 ( 注意: 不影响顾客重新开通其他会员卡 )。'
      )
    }
    if (data.useLimitRule.balanceClearExpire) {
      instructionsArray.push('此卡过期后该会员的实充余额自动清零。')
    }
    if (data.useLimitRule.giftClearExpire) {
      instructionsArray.push('此卡过期后该会员的赠送余额自动清零。')
    }
  }

  // 写入params
  params.instructionsArray = instructionsArray

  // 拼接权益说明
  const privilegeArray = []
  // 1.折扣
  if (data.category.categoryDiscount !== 100) {
    privilegeArray.push(
      `消费最低可享${data.category.categoryDiscount / 10}折。`
    )
  }

  // 2.充送rechargeAward
  if (data.rechargeAward.length > 0) {
    // 有规则
    switch (data.rechargeAward[0].calculateWay) {
      case 1:
        //   calculateWay 1
        data.rechargeAward.forEach((item, index) => {
          let calculateWayText1 = `单次充值满${item.baseAmount / 100}元送`
          // 赠送余额
          if (item.giftType === 1 && item.giftBalance !== 0) {
            calculateWayText1 += `余额${item.giftBalance / 100}元，`
          } else if (item.giftType === 2 && item.giftPercent !== 0) {
            calculateWayText1 += `充值金额的${item.giftPercent}%，`
          }
          // 赠送积分
          if (item.giftPoints !== 0) {
            calculateWayText1 += `积分${item.giftPoints}个，`
          }
          // 赠送优惠券
          if (item.couponAwards.length !== 0) {
            item.couponAwards.forEach(couponAwardsItem => {
              calculateWayText1 += `${couponAwardsItem.couponName}优惠券${couponAwardsItem.amount}张，`
            })
          }
          calculateWayText1 = calculateWayText1.slice(calculateWayText1.length - 1) === '，' ? calculateWayText1.slice(0, -1) + '。' : calculateWayText1
          privilegeArray.push(calculateWayText1)
        })
        break
      default:
        // 累计充值金额 calculateWay 2
        let calculateWayText2 = `每充值满${data.rechargeAward[0].baseAmount / 100}元送`

        // 赠送余额
        if (data.rechargeAward[0].giftBalance !== 0) {
          calculateWayText2 += `余额${data.rechargeAward[0].giftBalance / 100}元，`
        }

        // 赠送积分
        if (data.rechargeAward[0].giftPoints !== 0) {
          calculateWayText2 += `积分${data.rechargeAward[0].giftPoints}个，`
        }

        // 赠送优惠券
        if (data.rechargeAward[0].couponAwards.length !== 0) {
          data.rechargeAward[0].couponAwards.forEach(couponAwardsItem => {
            calculateWayText2 += `${couponAwardsItem.couponName}优惠券${couponAwardsItem.amount}张，`
          })
        }
        calculateWayText2 = calculateWayText2.slice(calculateWayText2.length - 1) === '，' ? calculateWayText2.slice(0, -1) + '。' : calculateWayText2
        privilegeArray.push(calculateWayText2)
        break
    }
  }

  // 积分系数
  if (enableConsumeBonus && data.category.multiplePoints && data.category.multiplePoints !== 10) {
    privilegeArray.push(`消费享受${data.category.multiplePoints / 10}倍积分。`)
  }

  // 自定义权益
  if (data.category.customBenefit) {
    JSON.parse(data.category.customBenefit).forEach((item, index) => {
      privilegeArray.push(item.value)
    })
  }

  // 写入params
  params.privilegeArray = privilegeArray
  return params
}
